/* Copyright (c) 2024-2025 The Khronos Group Inc.
 * Copyright (c) 2024-2025 Valve Corporation
 * Copyright (c) 2024-2025 LunarG, Inc.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

#include "utils/vk_struct_compare.h"
#include "utils/image_utils.h"
#include <vulkan/utility/vk_struct_helper.hpp>
#include <cstring>

static inline bool ComparePipelineSampleLocationsStateCreateInfo(const VkPipelineSampleLocationsStateCreateInfoEXT &a,
                                                                 const VkPipelineSampleLocationsStateCreateInfoEXT &b) {
    // Having VkSampleLocationEXT not confirmed to matter for the VU this is being used for, so just check the Count is good enough
    return (a.sampleLocationsEnable == b.sampleLocationsEnable) &&
           (a.sampleLocationsInfo.sampleLocationsPerPixel == b.sampleLocationsInfo.sampleLocationsPerPixel) &&
           (a.sampleLocationsInfo.sampleLocationGridSize.height == b.sampleLocationsInfo.sampleLocationGridSize.height) &&
           (a.sampleLocationsInfo.sampleLocationGridSize.width == b.sampleLocationsInfo.sampleLocationGridSize.width) &&
           (a.sampleLocationsInfo.sampleLocationsCount == b.sampleLocationsInfo.sampleLocationsCount);
}

bool ComparePipelineMultisampleStateCreateInfo(const VkPipelineMultisampleStateCreateInfo &a,
                                               const VkPipelineMultisampleStateCreateInfo &b) {
    bool valid_mask = true;
    if (a.pSampleMask && b.pSampleMask && (a.rasterizationSamples == b.rasterizationSamples)) {
        uint32_t length = (SampleCountSize(a.rasterizationSamples) + 31) / 32;
        for (uint32_t i = 0; i < length; i++) {
            if (a.pSampleMask[i] != b.pSampleMask[i]) {
                valid_mask = false;
                break;
            }
        }
    } else if (a.pSampleMask || b.pSampleMask) {
        valid_mask = false;  // one is not null
    }

    bool valid_pNext = true;
    if (a.pNext && b.pNext) {
        auto *a_sample_location = vku::FindStructInPNextChain<VkPipelineSampleLocationsStateCreateInfoEXT>(a.pNext);
        auto *b_sample_location = vku::FindStructInPNextChain<VkPipelineSampleLocationsStateCreateInfoEXT>(b.pNext);
        if (a_sample_location && b_sample_location) {
            if (!ComparePipelineSampleLocationsStateCreateInfo(*a_sample_location, *b_sample_location)) {
                valid_pNext = false;
            }
        } else if (a_sample_location != b_sample_location) {
            valid_pNext = false;  // both are not null
        }
    } else if (a.pNext != b.pNext) {
        valid_pNext = false;  // both are not null
    }

    return (a.sType == b.sType) && (valid_pNext) && (a.flags == b.flags) && (a.rasterizationSamples == b.rasterizationSamples) &&
           (a.sampleShadingEnable == b.sampleShadingEnable) && (a.minSampleShading == b.minSampleShading) && (valid_mask) &&
           (a.alphaToCoverageEnable == b.alphaToCoverageEnable) && (a.alphaToOneEnable == b.alphaToOneEnable);
}

bool CompareDescriptorSetLayoutBinding(const VkDescriptorSetLayoutBinding &a, const VkDescriptorSetLayoutBinding &b) {
    return (a.binding == b.binding) && (a.descriptorType == b.descriptorType) && (a.descriptorCount == b.descriptorCount) &&
           (a.stageFlags == b.stageFlags) && (a.pImmutableSamplers == b.pImmutableSamplers);
}

bool ComparePipelineColorBlendAttachmentState(const VkPipelineColorBlendAttachmentState &a,
                                              const VkPipelineColorBlendAttachmentState &b) {
    return (a.blendEnable == b.blendEnable) && (a.srcColorBlendFactor == b.srcColorBlendFactor) &&
           (a.dstColorBlendFactor == b.dstColorBlendFactor) && (a.colorBlendOp == b.colorBlendOp) &&
           (a.srcAlphaBlendFactor == b.srcAlphaBlendFactor) && (a.dstAlphaBlendFactor == b.dstAlphaBlendFactor) &&
           (a.alphaBlendOp == b.alphaBlendOp) && (a.colorWriteMask == b.colorWriteMask);
}

bool ComparePipelineFragmentShadingRateStateCreateInfo(const VkPipelineFragmentShadingRateStateCreateInfoKHR &a,
                                                       const VkPipelineFragmentShadingRateStateCreateInfoKHR &b) {
    // Since this is chained in a pnext, we don't want to check the pNext/sType
    return (a.fragmentSize.width == b.fragmentSize.width) && (a.fragmentSize.height == b.fragmentSize.height) &&
           (a.combinerOps[0] == b.combinerOps[0]) && (a.combinerOps[1] == b.combinerOps[1]);
}

static inline bool CompareSamplerYcbcrConversionInfo(const VkSamplerYcbcrConversionInfo &a, const VkSamplerYcbcrConversionInfo &b) {
    return a.conversion == b.conversion;
}

static inline bool CompareSamplerBorderColorComponentMappingCreateInfo(const VkSamplerBorderColorComponentMappingCreateInfoEXT &a,
                                                                       const VkSamplerBorderColorComponentMappingCreateInfoEXT &b) {
    return (a.components.r == b.components.r) && (a.components.g == b.components.g) && (a.components.b == b.components.b) &&
           (a.components.a == b.components.a) && (a.srgb == b.srgb);
}

static inline bool CompareSamplerCustomBorderColorCreateInfo(const VkSamplerCustomBorderColorCreateInfoEXT &a,
                                                             const VkSamplerCustomBorderColorCreateInfoEXT &b) {
    return (memcmp(a.customBorderColor.uint32, b.customBorderColor.uint32,
                   sizeof(VkSamplerCustomBorderColorCreateInfoEXT::customBorderColor)) == 0 &&
            a.format == b.format);
}
// to be sure there are gaps between fields and its safe to use memcmp
static_assert(sizeof(VkSamplerCustomBorderColorCreateInfoEXT::customBorderColor) == 16);

bool CompareSamplerCreateInfo(const VkSamplerCreateInfo &a, const VkSamplerCreateInfo &b) {
    // VkSamplerYcbcrConversionInfo
    auto *a_ycbcr_conversion = vku::FindStructInPNextChain<VkSamplerYcbcrConversionInfo>(a.pNext);
    auto *b_ycbcr_conversion = vku::FindStructInPNextChain<VkSamplerYcbcrConversionInfo>(b.pNext);
    if (a_ycbcr_conversion || b_ycbcr_conversion) {  // at least one not null
        if (!a_ycbcr_conversion || !b_ycbcr_conversion) {
            return false;  // one null, other not null
        }
        if (!CompareSamplerYcbcrConversionInfo(*a_ycbcr_conversion, *b_ycbcr_conversion)) {
            return false;
        }
    }
    // VkSamplerBorderColorComponentMappingCreateInfoEXT
    auto *a_component_mapping = vku::FindStructInPNextChain<VkSamplerBorderColorComponentMappingCreateInfoEXT>(a.pNext);
    auto *b_component_mapping = vku::FindStructInPNextChain<VkSamplerBorderColorComponentMappingCreateInfoEXT>(b.pNext);
    if (a_component_mapping || b_component_mapping) {  // at least one not null
        if (!a_component_mapping || !b_component_mapping) {
            return false;  // one null, other not null
        }
        if (!CompareSamplerBorderColorComponentMappingCreateInfo(*a_component_mapping, *b_component_mapping)) {
            return false;
        }
    }
    // VkSamplerCustomBorderColorCreateInfoEXT
    auto *a_border_color = vku::FindStructInPNextChain<VkSamplerCustomBorderColorCreateInfoEXT>(a.pNext);
    auto *b_border_color = vku::FindStructInPNextChain<VkSamplerCustomBorderColorCreateInfoEXT>(b.pNext);
    if (a_border_color || b_border_color) {  // at least one not null
        if (!a_border_color || !b_border_color) {
            return false;  // one null, other not null
        }
        if (!CompareSamplerCustomBorderColorCreateInfo(*a_border_color, *b_border_color)) {
            return false;
        }
    }
    // VkSamplerReductionModeCreateInfo
    auto get_reduction_mode = [](const VkSamplerCreateInfo &ci) {
        if (auto *reduction_mode_ci = vku::FindStructInPNextChain<VkSamplerReductionModeCreateInfo>(ci.pNext)) {
            return reduction_mode_ci->reductionMode;
        }
        // AVERAGE is default reduction mode (used when pNext does not specify VkSamplerReductionModeCreateInfo)
        return VK_SAMPLER_REDUCTION_MODE_WEIGHTED_AVERAGE;
    };
    const VkSamplerReductionMode a_reduction_mode = get_reduction_mode(a);
    const VkSamplerReductionMode b_reduction_mode = get_reduction_mode(b);
    if (a_reduction_mode != b_reduction_mode) {
        return false;
    }
    // Commons
    return (a.flags == b.flags) && (a.magFilter == b.magFilter) && (a.minFilter == b.minFilter) && (a.mipmapMode == b.mipmapMode) &&
           (a.addressModeU == b.addressModeU) && (a.addressModeV == b.addressModeV) && (a.addressModeW == b.addressModeW) &&
           (a.mipLodBias == b.mipLodBias) && (a.anisotropyEnable == b.anisotropyEnable) && (a.maxAnisotropy == b.maxAnisotropy) &&
           (a.compareEnable == b.compareEnable) && (a.compareOp == b.compareOp) && (a.minLod == b.minLod) &&
           (a.maxLod == b.maxLod) && (a.borderColor == b.borderColor) && (a.unnormalizedCoordinates == b.unnormalizedCoordinates);
}

bool CompareDependencyInfo(const VkDependencyInfo &a, const VkDependencyInfo &b) {
    if (a.dependencyFlags != b.dependencyFlags || a.memoryBarrierCount != b.memoryBarrierCount ||
        a.bufferMemoryBarrierCount != b.bufferMemoryBarrierCount || a.imageMemoryBarrierCount != b.imageMemoryBarrierCount) {
        return false;
    }
    for (uint32_t i = 0; i < b.memoryBarrierCount; ++i) {
        if (b.pMemoryBarriers[i].srcStageMask != a.pMemoryBarriers[i].srcStageMask ||
            b.pMemoryBarriers[i].srcAccessMask != a.pMemoryBarriers[i].srcAccessMask ||
            b.pMemoryBarriers[i].dstStageMask != a.pMemoryBarriers[i].dstStageMask ||
            b.pMemoryBarriers[i].dstAccessMask != a.pMemoryBarriers[i].dstAccessMask) {
            return false;
        }
    }
    for (uint32_t i = 0; i < b.bufferMemoryBarrierCount; ++i) {
        if (b.pBufferMemoryBarriers[i].srcStageMask != a.pBufferMemoryBarriers[i].srcStageMask ||
            b.pBufferMemoryBarriers[i].srcAccessMask != a.pBufferMemoryBarriers[i].srcAccessMask ||
            b.pBufferMemoryBarriers[i].dstStageMask != a.pBufferMemoryBarriers[i].dstStageMask ||
            b.pBufferMemoryBarriers[i].dstAccessMask != a.pBufferMemoryBarriers[i].dstAccessMask ||
            b.pBufferMemoryBarriers[i].srcQueueFamilyIndex != a.pBufferMemoryBarriers[i].srcQueueFamilyIndex ||
            b.pBufferMemoryBarriers[i].dstQueueFamilyIndex != a.pBufferMemoryBarriers[i].dstQueueFamilyIndex ||
            b.pBufferMemoryBarriers[i].buffer != a.pBufferMemoryBarriers[i].buffer ||
            b.pBufferMemoryBarriers[i].offset != a.pBufferMemoryBarriers[i].offset ||
            b.pBufferMemoryBarriers[i].size != a.pBufferMemoryBarriers[i].size) {
            return false;
        }
    }

    for (uint32_t i = 0; i < b.imageMemoryBarrierCount; ++i) {
        if (b.pImageMemoryBarriers[i].srcStageMask != a.pImageMemoryBarriers[i].srcStageMask ||
            b.pImageMemoryBarriers[i].srcAccessMask != a.pImageMemoryBarriers[i].srcAccessMask ||
            b.pImageMemoryBarriers[i].dstStageMask != a.pImageMemoryBarriers[i].dstStageMask ||
            b.pImageMemoryBarriers[i].dstAccessMask != a.pImageMemoryBarriers[i].dstAccessMask ||
            b.pImageMemoryBarriers[i].oldLayout != a.pImageMemoryBarriers[i].oldLayout ||
            b.pImageMemoryBarriers[i].newLayout != a.pImageMemoryBarriers[i].newLayout ||
            b.pImageMemoryBarriers[i].srcQueueFamilyIndex != a.pImageMemoryBarriers[i].srcQueueFamilyIndex ||
            b.pImageMemoryBarriers[i].dstQueueFamilyIndex != a.pImageMemoryBarriers[i].dstQueueFamilyIndex ||
            b.pImageMemoryBarriers[i].image != a.pImageMemoryBarriers[i].image ||
            b.pImageMemoryBarriers[i].subresourceRange.aspectMask != a.pImageMemoryBarriers[i].subresourceRange.aspectMask ||
            b.pImageMemoryBarriers[i].subresourceRange.baseMipLevel != a.pImageMemoryBarriers[i].subresourceRange.baseMipLevel ||
            b.pImageMemoryBarriers[i].subresourceRange.levelCount != a.pImageMemoryBarriers[i].subresourceRange.levelCount ||
            b.pImageMemoryBarriers[i].subresourceRange.baseArrayLayer !=
                a.pImageMemoryBarriers[i].subresourceRange.baseArrayLayer ||
            b.pImageMemoryBarriers[i].subresourceRange.layerCount != a.pImageMemoryBarriers[i].subresourceRange.layerCount) {
            return false;
        }
    }
    return true;
}
